frontend/app/src/shared/components/display/pie-chart.tsx (1)

38-38: Remove unnecessary empty className.

The empty string className adds no value and creates noise in the DOM.

Apply this diff to clean up:

-      <RPieChart width={100} height={60} className="">
+      <RPieChart width={100} height={60}>

frontend/app/src/entities/diff/checks/checks.tsx (1)

34-34: Optional chaining is defensive but unnecessary.

After the isPending check on line 25, validators should always be defined. The optional chaining validators?.map is safe but suggests uncertainty about the data shape.

If validators is always defined after loading, consider removing the optional chaining for clarity:

-        {validators?.map((item: any) => (
+        {validators.map((item: any) => (

frontend/app/src/entities/diff/api/get-validators-from-api.ts (3)

5-7: Prefer a list variable over an inline array literal.

Using [$id] is valid GraphQL, but passing a dedicated list variable is clearer and easier to reuse.

Proposed:

-  query GET_CORE_VALIDATORS($id: ID!) {
-    CoreValidator(proposed_change__ids: [$id]) {
+  query GET_CORE_VALIDATORS($ids: [ID!]!) {
+    CoreValidator(proposed_change__ids: $ids) {

And:

-    variables: { id: proposedChangeId },
+    variables: { ids: [proposedChangeId] },

---

5-6: Align names: constant vs operation.

const GET_VALIDATORS wraps query GET_CORE_VALIDATORS. Consider renaming one to match the other for grep-ability.

---

43-54: Add typed response/variables (if codegen is available).

Return a typed result (e.g., generated GET_CORE_VALIDATORSQuery) to avoid any downstream. If using GraphQL Code Generator, import the typed document and set the generic on query<Resp, Vars>.

frontend/app/src/entities/diff/checks/checks-summary.tsx (2)

103-103: Avoid passing a boolean to onClick.

Pass undefined when disabled to satisfy expected handler type and avoid accidental booleans.

-                <PieChart data={data} onClick={() => canRetry(data) && handleRetry(kind)}>
+                <PieChart data={data} onClick={canRetry(data) ? () => handleRetry(kind) : undefined}>

---

105-111: Improve retry overlay accessibility.

Make the hover‑only control keyboard‑accessible with semantics; optional but recommended.

-                    <div className="invisible absolute group-hover:visible">
+                    <div
+                      className="invisible absolute group-hover:visible"
+                      role="button"
+                      tabIndex={0}
+                      aria-label={`Retry ${schemaKindLabel[kind]?.replace("Validator", "").trim()} checks`}
+                      onKeyDown={(e) => {
+                        if ((e.key === "Enter" || e.key === " ") && canRetry(data)) handleRetry(kind);
+                      }}
+                    >

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

frontend/app/src/entities/diff/domain/diff.query-keys.ts (2)

22-23: Add as const assertion for type safety.

The proposedChangeValidatorsKeys.all array should use as const to match the pattern of other query keys in this file (lines 4, 10, 14, 19) and ensure proper type inference.

Apply this diff:

 export const proposedChangeValidatorsKeys = {
-  all: ["proposed-change-validators"],
+  all: ["proposed-change-validators"] as const,
   allWithinProposedChange: (proposedChangeId: string) => [

---

24-27: Add as const assertion for type safety.

The allWithinProposedChange function should return a readonly tuple by adding as const to match the pattern on line 6.

Apply this diff:

   allWithinProposedChange: (proposedChangeId: string) => [
     ...proposedChangeValidatorsKeys.all,
     proposedChangeId,
-  ],
+  ] as const,
 };

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

frontend/app/src/shared/components/display/pie-chart.tsx (1)

32-32: Restore click affordance and add keyboard/a11y semantics when clickable.

Bring back the pointer cursor and make the div operable via Enter/Space only when onClick exists.

-    <div className={"relative"} onClick={handleClick}>
+    <div
+      className={`relative ${onClick ? "cursor-pointer" : ""}`}
+      onClick={handleClick}
+      role={onClick ? "button" : undefined}
+      tabIndex={onClick ? 0 : undefined}
+      onKeyDown={(e) => {
+        if (!onClick) return;
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          onClick();
+        }
+      }}
+    >

frontend/app/src/entities/diff/checks/checks-summary.tsx (1)

51-66: Harden handleRetry: remove non-null assertions, add guards, reentrancy block, and onError toast.

Unsafe ! on proposedChangeId and VALIDATIONS_ENUM_MAP[validator], no auth/ID checks, no onError, and re-entrancy not blocked. Also async is unused. Apply:

-  const handleRetry = async (validator: string) => {
-    mutate(
-      {
-        proposedChangeId: proposedChangeId!,
-        checkType: VALIDATIONS_ENUM_MAP[validator]!,
-      },
-      {
-        onSuccess: () => {
-          queryClient.invalidateQueries({
-            queryKey: proposedChangeValidatorsKeys.allWithinProposedChange(proposedChangeId!),
-          });
-          toast(<Alert type={ALERT_TYPES.SUCCESS} message="Checks are running" />);
-        },
-      }
-    );
-  };
+  const handleRetry = (validator: keyof typeof VALIDATIONS_ENUM_MAP) => {
+    if (isPending) return;
+    if (!isAuthenticated) {
+      toast(<Alert type={ALERT_TYPES.ERROR} message="You must be signed in to retry checks" />);
+      return;
+    }
+    const pcId = proposedChangeId;
+    if (!pcId) {
+      toast(<Alert type={ALERT_TYPES.ERROR} message="Missing proposed change id" />);
+      return;
+    }
+    const checkType = VALIDATIONS_ENUM_MAP[validator];
+    if (!checkType) {
+      toast(<Alert type={ALERT_TYPES.ERROR} message={`Unknown validator: ${String(validator)}`} />);
+      return;
+    }
+    mutate(
+      { proposedChangeId: pcId, checkType },
+      {
+        onSuccess: () => {
+          queryClient.invalidateQueries({
+            queryKey: proposedChangeValidatorsKeys.allWithinProposedChange(pcId),
+          });
+          toast(<Alert type={ALERT_TYPES.SUCCESS} message="Checks are running" />);
+        },
+        onError: () => {
+          toast(<Alert type={ALERT_TYPES.ERROR} message="Failed to start checks" />);
+        },
+      }
+    );
+  };

frontend/app/src/shared/components/display/pie-chart.tsx (3)

3-6: Tighten prop types (avoid any[] and Function).

Stronger typing improves safety and editor help.

-type PieChartProps = {
-  data: any[];
-  onClick?: Function;
-};
+type SliceDatum = { name: string; value: number; className?: string };
+type PieChartProps = {
+  data: SliceDatum[];
+  onClick?: () => void;
+};

---

22-24: Minor: inline destructuring is fine; consider typing handlers for clarity.
No behavior change, but adding explicit types helps future edits.

-export const PieChart = (props: PieChartProps) => {
-  const { data, onClick } = props;
+export const PieChart = ({ data, onClick }: PieChartProps) => {
+  const handleClick: () => void = () => {
+    if (!onClick) return;
+    onClick();
+  };

---

1-1: Alias Recharts Tooltip to avoid confusion with app UI Tooltip.

Project also exports a Tooltip component (frontend/app/src/shared/components/ui/tooltip.tsx). Alias the Recharts one to make intent obvious.

-import { Cell, Pie, PieChart as RPieChart, Tooltip } from "recharts";
+import { Cell, Pie, PieChart as RPieChart, Tooltip as RechartsTooltip } from "recharts";
...
-        <Tooltip content={renderCustomizedTooltip} />
+        <RechartsTooltip content={renderCustomizedTooltip} />

If both tooltips appear in this module in future, this avoids naming collisions. Based on relevant UI tooltip file.

Also applies to: 47-47

frontend/app/src/entities/diff/checks/checks-summary.tsx (1)

104-116: A11y: reveal controls on keyboard focus, not only hover.

Add focus styles so keyboard users can access Retry; today it's hover-only.

-                    className={classNames(
-                      "text-xs",
-                      canRetry(data) && "absolute text-xs group-hover:invisible"
-                    )}
+                    className={classNames(
+                      "text-xs",
+                      canRetry(data) && "absolute text-xs group-hover:invisible group-focus-within:invisible"
+                    )}
...
-                    <div className="invisible absolute group-hover:visible">
+                    <div className="invisible absolute group-hover:visible group-focus-within:visible">

Consider updating Retry to render a native with tabIndex, role, and keyboard handlers. I can draft that if helpful.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

frontend/app/src/entities/diff/checks/checks-summary.tsx (3)

26-29: Tighten prop types (avoid any[]).
Use the minimal readonly shape you actually need (__typename).

-type ChecksSummaryProps = {
-  validators: any[];
-  isLoading: boolean;
-};
+type ChecksSummaryProps = {
+  validators: ReadonlyArray<{ __typename: string }>;
+  isLoading: boolean;
+};

---

50-64: Harden mutation: remove non‑null assertions, add guards and onError.
Prevent runtime throws and surface failures to users.

-  const handleRetry = async (validator: string) => {
-    mutate(
-      {
-        proposedChangeId: proposedChangeId!,
-        checkType: VALIDATIONS_ENUM_MAP[validator]!,
-      },
-      {
-        onSuccess: () => {
-          queryClient.invalidateQueries({
-            queryKey: proposedChangeValidatorsKeys.allWithinProposedChange(proposedChangeId!),
-          });
-          toast(<Alert type={ALERT_TYPES.SUCCESS} message="Checks are running" />);
-        },
-      }
-    );
-  };
+  const handleRetry = async (validator: string) => {
+    if (isPending) return;
+    const pcId = proposedChangeId;
+    if (!pcId) {
+      toast(<Alert type={ALERT_TYPES.ERROR} message="Missing proposed change id" />);
+      return;
+    }
+    const checkType = VALIDATIONS_ENUM_MAP[validator as keyof typeof VALIDATIONS_ENUM_MAP];
+    if (!checkType) {
+      toast(<Alert type={ALERT_TYPES.ERROR} message={`Unknown validator: ${validator}`} />);
+      return;
+    }
+    mutate(
+      { proposedChangeId: pcId, checkType },
+      {
+        onSuccess: () => {
+          queryClient.invalidateQueries({
+            queryKey: proposedChangeValidatorsKeys.allWithinProposedChange(pcId),
+          });
+          toast(<Alert type={ALERT_TYPES.SUCCESS} message="Checks are running" />);
+        },
+        onError: () => {
+          toast(<Alert type={ALERT_TYPES.ERROR} message="Failed to start checks" />);
+        },
+      }
+    );
+  };

---

113-121: Per‑validator Retry: gate by auth; compute in‑progress from stats.
data.inProgress doesn’t exist; also block unauthenticated clicks.

                   {canRetry(data) && (
                     <div className="invisible absolute group-hover:visible">
                       <Retry
-                        isLoading={isPending || isLoading || !!data.inProgress}
-                        isDisabled={!canRetry(data)}
-                        onClick={() => canRetry(data) && handleRetry(kind)}
+                        isLoading={
+                          isPending ||
+                          isLoading ||
+                          data.some((s: any) => s.name === CHECKS_LABEL.IN_PROGRESS && !!(s as any).value)
+                        }
+                        isDisabled={!isAuthenticated || !canRetry(data)}
+                        onClick={() => isAuthenticated && canRetry(data) && handleRetry(kind)}
                       />
                     </div>
                   )}

frontend/app/src/entities/diff/domain/run-check.mutation.ts (1)

5-9: Type the mutation and allow options pass-through for better DX.

Annotate generics so mutate() is correctly typed, and optionally accept options to extend handlers.

-import { useMutation } from "@tanstack/react-query";
+import { useMutation, type UseMutationOptions } from "@tanstack/react-query";
+import type { CheckType } from "@/shared/api/graphql/generated/graphql";

 import { runCheck } from "@/entities/diff/domain/run-check";

-export function useRunCheckMutation() {
-  return useMutation({
-    mutationFn: runCheck,
-  });
-}
+type Vars = { proposedChangeId: string; checkType: CheckType };
+export function useRunCheckMutation(
+  options?: UseMutationOptions<void, unknown, Vars, unknown>
+) {
+  return useMutation<void, unknown, Vars>({
+    mutationFn: runCheck,
+    ...options,
+  });
+}

frontend/app/src/entities/diff/checks/checks.tsx (1)

10-19: Optional: guard missing route param instead of non‑null assertion.

Avoid proposedChangeId!; render an error if absent.

 export const Checks = () => {
   const { proposedChangeId } = useParams();

-  const {
+  if (!proposedChangeId) {
+    return <ErrorScreen message="Missing proposed change id." />;
+  }
+
+  const {
     isPending,
     error,
     data: validators,
   } = useGetValidatorsQuery({
-    proposedChangeId: proposedChangeId!,
+    proposedChangeId,
   });

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro